В C++ при работе с операторами существует последовательность выполнения всех операций. Приоритет операторов используется при работе с несколькими операторами в выражении нашего кода. Например, при работе с операторами сложения, вычитания, умножения и деления операции умножения и деления выполняются сначала слева направо, поскольку они имеют высокий приоритет, а операции сложения и вычитания выполняются слева направо, поскольку они имеют высокий приоритет. низкий приоритет, чем умножение и деление. Но если выражение содержит только операторы сложения и вычитания, операция выполняется просто слева направо. Здесь мы покажем таблицу приоритета операторов и примеры приоритета операторов.
Приоритет операторов арифметических операций
Операция | Операторы | Приоритет |
---|---|---|
круглые скобки | () | Эти скобки являются действующими. |
умножение, деление, модуль | *, /, % | Эти операции выполняются в порядке слева направо. |
сложение, вычитание | +, – | Эти операции выполняются в конце и их последовательность слева направо. |
Пример 1:
Давайте начнем наш код с включения заголовочного файла с именем «iostrem». Многие функции объявлены в этом заголовочном файле «iostream», который мы будем использовать в нашем коде. Под ним мы вводим «namespace std» и вызываем «main()». Здесь, в «main()», мы объявляем переменные с именами «i», «j» и «k» с помощью «int», а значения, которые мы здесь передаем, — «10», «37» и «29». соответственно. Мы также объявляем переменную «r», в которой сохраняется результат.
После этого мы набираем выражение, используя операторы «+», «/» и «-». Как мы уже объясняли ранее, эти операции выполняются последовательно. Выражение, которое мы сюда поместили, — это «i + j/k – j», в котором сначала выполняется деление, а затем выполняются операции сложения и вычитания. Он отображает результат в целочисленных значениях, поскольку мы объявляем переменную «r» как целое число. Далее мы отображаем вычисленный результат с помощью «cout».
Код 1:
#includeс использованием пространство имен стандартный ;
интервал основной ( )
{
интервал я '=' 10 , Дж '=' 37 , к '=' 29 , р ;
р '=' я + дж / к - дж ;
расчет << 'Результатом данного выражения является = ' << р ;
возвращаться 0 ;
}
Выход:
Выход — «-26» после выполнения всех операций. Этот результат вычисляется в соответствии с приоритетом операторов, предусмотренным языком C++.
Пример 2:
В этом коде, после включения файла заголовка и вызова «main()», мы инициализируем переменную «int» с именем «val1» и помещаем выражение, в которое вводим «9 + 18 * 7». Здесь сначала выполняется умножение, а затем к умноженному значению добавляется «9». Далее мы инициализируем «int val2» как «9 + (18 * 7)».
Здесь сначала решаются скобки. Затем выполняется добавление. После этого мы также инициализируем «int val3» выражением «(9 + 18) * 7». В этом выражении сначала снова работают скобки, а затем выполняется умножение. Значения выражений одинаковы, но они дают уникальные результаты из-за приоритета операторов. Теперь мы двинемся дальше и распечатаем все результаты, которые хранятся в переменных «val1», «val2» и «val3», с помощью «cout».
Код 2:
#includeс использованием пространство имен стандартный ;
интервал основной ( ) {
интервал выбор1 '=' 9 + 18 * 7 ;
интервал val2 '=' 9 + ( 18 * 7 ) ;
интервал val3 '=' ( 9 + 18 ) * 7 ;
расчет << 'Первый результат показывает = ' << выбор1 << конец ;
расчет << 'Второй результат показывает = ' << val2 << конец ;
расчет << 'Третий результат показывает = ' << val3 << конец ;
возвращаться 0 ;
}
Выход:
Результат, который мы получаем после вычисления данного выражения, следующий. Мы видим, что третий результат не совпадает с двумя другими, хотя значения одинаковы. Это связано с приоритетом оператора, который применяется к оператору выражения.
Пример 3:
Здесь мы инициализируем разные переменные разными значениями, и тип данных всех этих переменных — «int». У нас есть целочисленные переменные «a», «b», «c» и «d» со значениями «14», «9», «15» и «29» соответственно. После этого инициализируем «int R1» и выражение, которое сюда помещаем, — «a+b)*c/d». В первую очередь решаются скобки. Затем выполняются операции умножения и деления. Мы также отображаем результат ниже. Затем у нас есть «int R2» с выражением «a – b * (d + a) + c». Здесь он также решает круглые скобки, а затем вычитание и сложение выполняются в соответствии с приоритетом операторов. Мы также печатаем его результат и инициализируем «int R3», где вводится выражение «b – d + c * a». В этом выражении сначала выполняется умножение, затем вычитание и сложение. Результат этого выражения также отображается ниже. Теперь у нас есть последнее выражение «d+(a*b)/a», результат которого сохраняется в переменной «R4». В этом выражении сначала раскрываются круглые скобки, а затем делятся. В конце производится сложение. Результат этого выражения показан следующим образом:
Код 3:
#includeс использованием пространство имен стандартный ;
интервал основной ( ) {
интервал а '=' 14 ;
интервал б '=' 9 ;
интервал с '=' пятнадцать ;
интервал д '=' 29 ;
интервал Р1 '=' ( а + б ) * с / д ;
расчет << «(а + б) * в/д» << 'дает = ' << Р1 << конец ;
интервал Р2 '=' а - б * ( д + а ) + с ;
расчет << 'а - б(г+а)+в' << 'дает = ' << Р2 << конец ;
интервал Р3 '=' б - д + с * а ;
расчет << «б — г + в*а» << 'дает = ' << Р3 << конец ;
интервал Р4 '=' д + ( а * б ) / а ;
расчет << 'д+(а*б)/а' << 'дает = ' << Р4 << конец ;
возвращаться 0 ;
}
Выход:
Ниже приводится результат вычисления ранее упомянутых выражений. Мы получаем такой результат, потому что к операторам в выражении применяется приоритет оператора:
Пример 4:
Здесь мы инициализируем переменные «a1», «b1», «c1», «d1», «e1» и «f1» целочисленными значениями «64», «90», «11», «27», «34» и «98» соответственно. Здесь мы инициализируем «int result1» выражением «a1 + b1 – c1) * d1/f1», и результат сохраняется в переменной «result1». Здесь сначала решаются скобки. Затем последовательно вычисляются остальные операции. Затем мы печатаем «result1». Таким же образом мы вычисляем выражения и сохраняем их в разных переменных. Затем мы распечатываем все результаты отдельно, показывая, как работает приоритет операторов.
Код 4:
#includeс использованием пространство имен стандартный ;
интервал основной ( ) {
интервал а1 '=' 64 ;
интервал б1 '=' 90 ;
интервал с1 '=' одиннадцать ;
интервал d1 '=' 27 ;
интервал е1 '=' 3. 4 ;
интервал ф1 '=' 98 ;
интервал результат1 '=' ( а1 + б1 - с1 ) * d1 / ф1 ;
расчет << «Результат 1:» << результат1 << конец ;
интервал результат2 '=' а1 + ( ф1 * б1 ) / е1 ;
расчет << «Результат 2:» << результат2 << конец ;
интервал результат3 '=' е1 + d1 + а1 - с1 * б1 / а1 ;
расчет << «Результат 3:» << результат3 << конец ;
интервал результат4 '=' а1 - ф1 + ( б1 - d1 ) * с1 ;
расчет << «Результат 4:» << результат4 << конец ;
интервал результат5 '=' ( ф1 + ( а1 * ( б1 + а1 ) - ф1 ) * а1 + е1 ) ;
расчет << «Результат 5» << результат5 << конец ;
возвращаться 0 ;
}
Выход:
Здесь отображается вывод данного кода, который показывает результат всех выражений, которые мы ввели ранее. Все выражения вычисляются в соответствии с правилом приоритета порядка.
Заключение
Здесь мы рассмотрели «приоритет C++», глубоко изучив порядок операторов, в котором они вычисляются в программировании на C++. Мы также показали порядок операторов в виде таблицы, а затем выполнили множество примеров, на которых узнали, как выражения решаются в соответствии с приоритетом порядка в программировании на C++.