更改一元表达式中定义的运算符的优先级
是指通过调整运算符的优先级顺序来改变表达式的计算方式。一元表达式是指只涉及一个操作数的表达式。
在编程中，一元表达式常见的运算符有正号（+）和负号（-）。正号用于将操作数转换为正数，负号用于将操作数转换为负数。
更改一元表达式中定义的运算符的优先级可以通过使用括号来实现。括号可以改变运算符的执行顺序，优先计算括号内的表达式。通过将一元表达式用括号括起来，可以改变它的计算方式。
例如，原始的一元表达式是：-x，其中 x 是一个变量。默认情况下，负号运算符的优先级较高，先对 x 取负，然后再进行其他运算。
如果想要改变运算顺序，可以使用括号：-(x)，这样 x 先被括号括起来，先计算括号内的表达式，然后再对结果取负。
通过更改一元表达式中定义的运算符的优先级，可以根据需要调整表达式的计算顺序，以满足具体的需求。
需要注意的是，每种编程语言对于一元表达式的运算符优先级规则可能会有所不同，具体使用时需要参考对应编程语言的文档或规范。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云计算产品介绍：https://cloud.tencent.com/product
- 腾讯云数据库产品介绍：https://cloud.tencent.com/product/cdb
- 腾讯云服务器产品介绍：https://cloud.tencent.com/product/cvm
- 腾讯云音视频处理产品介绍：https://cloud.tencent.com/product/mps
- 腾讯云人工智能产品介绍：https://cloud.tencent.com/product/ai
- 腾讯云物联网产品介绍：https://cloud.tencent.com/product/iotexplorer
- 腾讯云移动开发产品介绍：https://cloud.tencent.com/product/mobile
- 腾讯云存储产品介绍：https://cloud.tencent.com/product/cos
- 腾讯云区块链产品介绍：https://cloud.tencent.com/product/bc
- 腾讯云元宇宙产品介绍：https://cloud.tencent.com/product/virtual-world
相关·内容
3回答
在C中，类型转换变量/值被认为是一元操作吗？
此外，类型转换整数值(可能在对其应用掩码之前)也是一元操作吗？比方说我有
((uint64_t)1 << 30 & 0xFFFF0000FFFF0000LL)
1是否用零(最多64位)填充，然后移位？
浏览 2提问于2014-03-07得票数 3
2回答
我正在研究一个c预处理器，并且发现，由于“已定义”是一个只使用预处理器的运算符，所以它的优先级级别从未列在其他c操作符中。因为这是一元化和逻辑性的，我会把它放在第二层，但是.
有人知道确切的答案吗？
浏览 0提问于2018-11-16得票数 1
回答已采纳
在浏览器控制台中执行时，它显示为SyntaxError: Unexpected token **。在节点中尝试：
> -1**2
...
...
...
...^C
我以为这是一个算术表达式，其中**是幂运算符。其他操作员没有这样的问题。
奇怪的是，在第二行输入*/会触发执行：
> -1**2
... */
-1**2
^^
SyntaxError: Unexpected token **
这是怎么回事？
浏览 8提问于2017-04-22得票数 58
回答已采纳
对于一个工具，我试图正确地解析SystemVerilog断言，并且对某些表达式的正确优先级感到困惑。SystemVerilog标准有一个很好的表，他们说not > until > always表示优先。但我不太明白这是如何与一元操作符交替工作的。
例如，由于not的优先级高于until，我们显然应该拥有：
not r1 until r2 ----> (not r1) until r2
而且，由于until的优先级高于always，我们显然应该拥有：
always r1 until r2 ----> always (r1 until r2)
浏览 3提问于2015-10-16得票数 1
3回答
在维基百科上查找运算符结合性时，我注意到delete具有从右到左的结合性。源被引用为，我检查了它，它属于第3组优先级，从右到左结合。所以我检查了
5.3一元表达式expr.unary
1)一元运算符的表达式由右向左分组。
一元表达式:后缀-表达式++强制转换-表达式单运算符强制转换-表达式大小(类型-id)大小.(标识符)对齐( type-id )no除-表达式新-表达式删除-表达式一元-运算符之一：*&+-！~之一
这意味着什么？delete到底有什么联想性？
浏览 7提问于2015-05-20得票数 5
回答已采纳
在C操作符的上下文中优先。实际上，将按以下方式对下列代码进行评估：
int32_t * result = (int32_t *) addr_base + offset;
|
|
↓
int32_t * result = ((int32_t *) addr_base) + offset;
然而，我在下面的表格中看到的是，cast和+应该从右到左进行评估。换句话说，在我的示例中，+对cast是正确的，因此我希望上面的第一条语句的计算方式如下：
int3
浏览 0提问于2019-07-26得票数 1
回答已采纳
当我在JavaScript中使用指数运算符(**)时，它通常按预期工作：
2 ** 2 // 4
2 ** -2 // 0.25
但当左操作数为负数时
-2 ** 2
我得到一个语法错误：
未捕获SyntaxError:意外标记**
我可以通过用括号将-2括起来来轻松地绕过它。
(-2) ** 2 // 4
但我很好奇是什么导致了这个错误。其他运算符(+ - * / %等)就没有这个问题。为什么**操作符会发生这种情况？
浏览 51提问于2018-08-31得票数 3
回答已采纳
4回答
我是C语言的初学者，假设我有这样一段代码：
#include <stdio.h>
void test(char *t)
{
t++;
*t = 'e';
}
void main()
{
char a[] = "anto";
printf("%c\n",a[1]);
test(a);
printf("%c\n",a[1]);
}
这是示例代码，我在这里了解指针是如何工作的。根据我的说法：
t++;
在上面的代码中，数组a的地址将通过调用函数test中的1 char递增。
浏览 0提问于2012-04-03得票数 0
回答已采纳
这会导致如下情况：
-1 ** 0.5 #=> -1
只有括号可以弥补这一点：
(-1) ** 0.5 #=> 6.123031769111886e-17+1.0i
这不如预期的1.i有利，但基本上是可以接受的。在我去Ruby bugs抱怨之前，我想知道这是不是有什么原因？
浏览 4提问于2012-11-11得票数 4
回答已采纳
a)点运算符( a.x )和索引运算符( ax )具有相同的优先级。因此，基于什么优先级规则，表达式a[x].SomeMember被计算为(a[x]).SomeMember而不是(a.SomeMember )[x]
b)转换运算符是一元运算符(因此优先级低于点运算符)，因此表达式(int)a.x的计算结果为(int)(a.x)
谢谢
浏览 0提问于2010-02-11得票数 2
回答已采纳
这很奇怪我注意到了。
为什么-5**2给-25，math.pow(-5,2)给出25，有什么特别的原因吗？答案应该是25。那么-25的原因是什么呢？
>>> -5**2
-25
>>> -5**4
-625
>>> 5**2
25
>>> 5**4
625
>>> import math
>>> pow(-5,2)
25
>>> pow(-5,4)
625
>>>
浏览 6提问于2016-04-20得票数 3
回答已采纳
我尝试创建一个包含两个浮点数的元组。例如，(4.0, 4.0)。但是，由于两个浮点数是相同的，所以我编写了4.0, * 2。
我想要做的事情可以写成：(4.0,) * 2。在Python中，将一个元组乘以一个告诉Python的整数，以便将这个次数的元组与其自身连接起来。所以(4.0,) * 2 = (4.0,) + (4.0,) = (4.0, 4.0)。好的。
我不想做的是4.0 * 2 (没有逗号)。实际上，这将使float 4.0本身乘以2：4.0 * 2 = 8.0。好的。
但这些行为都没有发生。我得到的不是8.0或(4.0, 4.0)，而是
TypeError: 'int&#
浏览 14提问于2017-12-15得票数 2
回答已采纳
为什么将变量中的值存储到幂运算符中(在Python3.6中进行了测试)又有什么关系？
>>> -7**2
-49
>>> y=-7
>>> y**2
49
第一个显然是错误的！
浏览 0提问于2019-04-12得票数 1
1回答
在C中，圆括号用于进行更多的操作，如函数调用和类型转换。
然而，它们也用于对许多子表达式进行分组，以更改运算符的顺序计算。
我的疑问是:当他们被用作分组运营商时，他们是否被认为是运营商？
很多人说他们是，很多人说不..。
浏览 2提问于2014-06-16得票数 5
回答已采纳
4回答
来自的C++运算符优先表(我知道这不是标准的，但标准没有讨论优先级或结合性)将一元运算符标记为右/左结合。
从对另一个问题的讨论中，我留下了疑惑。一元运算符是联合运算符有意义吗？
浏览 1提问于2012-10-19得票数 15
回答已采纳
2回答
我试图检测一个数字在数字原型中的函数中是否为负数。对于语法糖，我使用的是“.”若要将数字转换为对象，请执行以下操作。但当我评估一个负数时，结果却是一个正数：
Number.prototype.test = function() {
n = this.valueOf();
console.log(n);
console.log(typeof n);
return n;
};
-11..test()
// 11 - why???
// number
// -11
如果我使用Number对象，结果就是预期的结果：
Number(-11).test()
// -11
浏览 3提问于2015-10-24得票数 1
回答已采纳
我对C是新手。我读到数组下标操作符和指针算法对于访问成员variable.But来说是可互换的，在下面的代码中，当我使用->运算符访问成员变量时，当我使用->运算符来访问成员变量时，我得到了错误，.i am位，混淆了在.i am缺失下正在发生的事情。
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int x, y;
} Point;
int main ()
{
int numOf;
Point *myPoints = NULL;
浏览 2提问于2015-04-21得票数 2
回答已采纳
1回答
我试图用两种看似等价的方式从向量中提取值：
x <- c(1,2,3)
x[2:3]
# [1] 2 3
x[1+1:3]
# [1] 2 3 NA
我不明白为什么表达式x[2:3]产生与x[1+1:3]不同的结果--第二个表达式在末尾包含一个NA值。我遗漏了什么？
浏览 2提问于2014-06-07得票数 12
回答已采纳
1回答
一元算子的优先性
、、、
一些关于操作符优先级的信息源说，一元运算符如!、~、+、-比赋值=具有更高的优先级。然而，以下表达式是可能的：
!a = true # => false (with warning)
a # => true
~a = 1 # => -2
a # => 1
+a = 1 # => 1
a # => 1
-a = 1 # => -1
a # => 1
考虑到这些结果，我能想到的唯一可能的解释是，这些一元运算符的优先级低于赋值。如果是这样的话，那就意味着我上面提到的
浏览 3提问于2014-02-23得票数 8
回答已采纳
这是Python中操作符的层次顺序的结果吗？
not(True) * True
# False
True * not(True)
# SyntaxError: invalid syntax
浏览 6提问于2022-08-11得票数 21
3回答
我从这次讨论中提出了一个问题：
假设我有以下代码：
#include <stdio.h>
foo(char **ptr){
*ptr++;
}
int main()
{
char *ptr = malloc(64);
char arr[] = "Hello World!";
memcpy(ptr, arr, sizeof(arr));
foo(&ptr);
foo(&ptr);
printf("%s",ptr);
return 0;
}
我想知道这个程序的输出是什么
浏览 2提问于2021-11-16得票数 5
回答已采纳
4回答
有一个守则：
float x=-8.92;
int y=5;
printf("%u\n", sizeof x+y);
printf("%u\n", sizeof (x+y));
结论：
9
4
为什么会发生这种情况(结果9)？毕竟，这些都是简单的一元操作。
浏览 7提问于2020-12-24得票数 2
回答已采纳
根据Ecma-262，前缀增量和递减运算符定义为：
UpdateExpression :
LeftHandSideExpression ++
LeftHandSideExpression ‐‐
++ UnaryExpression
‐‐ UnaryExpression
这是令人惊讶的，因为后缀和前缀操作符都是在相同的规则中定义的，而且当一个一元表达式通常并不是更新运算符的有效参数时，它就是++ UnaryExpression。
在UnaryExpression本身以及其他前缀运算符中定义前缀增量和递减运算符似乎更清晰、更符合逻辑，其他C语法语言也是这样做的，例如
浏览 3提问于2018-06-15得票数 3
回答已采纳
我是一个C编程的新手，我想知道下面的内容是否等价：
&clockA->tick_time
和
&(clockA->tick_time)
这里有没有括号的影响？
浏览 0提问于2014-09-18得票数 1
2回答
派生指向列表的双指针
、、、
这是Node typedef struct s_list
{
void *content;
struct s_list *next;
} t_list; void ft_lstclear(t_list **lst, void (*del)(void*))
{
t_list *temp;
while ((*lst) != NULL)
{
temp = (*lst)->next;
del((*lst)->content);
free(
浏览 46提问于2021-11-19得票数 1
回答已采纳
几天前，我在java代码中做了一个错误，但它编译并运行良好。(尽管结果很奇怪。)
我的代码是：
public static void main(String args[]) {
String strOut;
char cSEP = '|';
String sSEP = "|";
strOut = "AA" + cSEP + "BB"; // Correct assignment
System.out.println(strOut); // The res
浏览 3提问于2019-11-05得票数 3
回答已采纳
VHDL-2008引入了压缩运算符，它接收一个逻辑元素的一维数组，并输出一个位值。引用“核查视野”第8卷第3期2012年10月：
VHDL-2008为逻辑数组类型(bit_vector、std_logic_vector、…)创建了AND、OR、NOR、NAND、XOR和XNOR的一元版本。。运算符应用于数组参数的每个元素(约简操作)，并产生一个元素结果。一元运算符与杂项运算符(**、ABS和NOT)具有相同的优先级。
LRM 9.2.2对力学作了解释，但激发这一问题的是9.1中的注2。
注2-涉及一元条件运算符或一元逻辑运算符与任何其他运算符组合的表达式的语法要求一元运算符及其操作数
浏览 1提问于2014-10-07得票数 1
回答已采纳
我正在为表达式做一个简单的编译器，但是我想不出如何使用Bison的优先关键字
在我的lexer中，我定义了以下检查：
'-' {ECHO;return(MINUS);}
然而，我注意到，在计算表达式时，'-‘可以有两个含义: 1)减法，2)否定一个数字，两者有不同的先例。
在我的解析器文件中，如何通过使用%左和%右来定义相联性来解释这一点？
我知道我能做到
%left PLUS
%left MINUS
... and so on
对于每个这样的标记，但是由于否定具有正确的结合性和更高的优先级，我如何将其包括在这里，因为我不认为我能做到。
%left PLUS
%
浏览 4提问于2014-10-24得票数 4
回答已采纳
我的朋友们，我是中国的c++，c，python和c#开发人员。所有的Javabook和所有的互联网站点，我在我自己的网站上都说过，java的先例就像我的文本下面的表格。优先级表表示：+expr和-expr是在相加+和-之上，也在乘法(例如*、/和% )之上。
例如
b*-a将被解释为(b)*(-a)，这是正确的，对表来说是正确的。
但是，当我跟着桌子
a+b不应该工作，因为在我在interpreted站点上看到的所有书籍中，优先级表都说Java应该这样解释它：
a(+b)
因此，我们应该得到一个错误，而不是一个加法，但是java在a和b之间做了一个加法，但通常情况下，当我遵循优先级表时，它不
浏览 4提问于2021-12-12得票数 -2
因此，C中的数组fib_sequence传递给函数为*fib_sequence[]。
当我访问一个元素时，我的函数分段错误：
*fib_sequence[i]
然而，当我这样做的时候，它就起作用了：
fib_sequence[0][i]
我是疯了还是这不是等价物？
这里引用的是整个函数，当只分配给索引1时，它失败了。
分段故障函数
void fib(int *fib_sequence[], int count) {
*fib_sequence = malloc(sizeof(int[count]));
for (int i = 0; i < count; i++) {
浏览 1提问于2019-01-23得票数 1
回答已采纳
C型运算符&&，||，.他们的Perl人类可读的版本"and"，"or"，.？
互联网代码似乎同时使用了这两种方法：
open (FILE, $file) or die("cannot open $file");
open (FILE, $file) || die("cannot open $file");
浏览 6提问于2009-07-16得票数 50
回答已采纳
1回答
用一元运算符对后缀问题进行修正
、、、、
我使用下面的逻辑实现从infix到postfix的转换，并在稍后对其进行评估。
在infix转换上的循环，并在每次迭代中执行以下操作：
- If space, ignore it.
- If operator, then keeps popping from the stack and add to the postfix output until the stack is empty or the top of the stack has a lower priority than the current operator. Then, push the current operator.
浏览 2提问于2020-05-20得票数 1
回答已采纳
我正在编写一个模拟器，我希望它与C中的宏完全一样。下面的代码使我感到困惑：
这是有效的代码，并返回true：
#if ((((1 + ((2)))))) == 3
这也是有效的代码，并返回true：
#define hi hello
#if defined (hi)
但是这将引发一个错误，而不是编译：
#define hi hello
#if defined ((hi))
这有什么特别的原因不起作用吗？看上去应该管用的。
如果您想要在线测试宏，这里有一个链接： (将-E作为参数)
这里有一个解释定义操作符的链接：
浏览 3提问于2020-10-13得票数 0
回答已采纳
1回答
我只是想澄清一下我对如何在表达式中应用布尔优先顺序的理解。我将使用以下优先级顺序给出一个示例：
1) NOT
2) AND
3) OR
给定表达式A NOT B AND C，我知道将首先计算NOT。但是，这是应用于表达式(B AND C)的其余部分，还是仅应用于下一个标记B
我目前的理解是，它是前者，所以它应该被评估为A NOT (B AND C)。这是正确的吗？
谢谢
浏览 6提问于2011-03-01得票数 0
回答已采纳
#include<stdio.h>
int main()
{
int a[2]={10,4};
int *k;
int *j;
j=a;
k=j;
printf("j=%d,k=%d\n\n",*j,*k);
*j++;
++*k;
printf("j=%d,k=%d",*j,*k);
return 0;
}
产出如下：
j=10 k=10 j=4 k=11
我认为应该有同样的结果，但事实并非如此。我想问一下是什么造成了这种差异。我没有找到原因。
浏览 3提问于2016-11-11得票数 0
回答已采纳
这将打印-2.4：
print(-3**0.8)
但这打印了一个虚数...？
a = -3
b = 0.8
print(a**b)
我不知道是什么导致了这个问题，这个问题破坏了我的程序。在a的正值和负值的一般情况下，如何使第二条语句的输出与第一条语句相同
浏览 0提问于2017-07-09得票数 2
5回答
今天我偶然发现了一个C语言的谜语，它给了我一个新的惊喜。
我不认为下面示例中的-1p可以编译，但它编译了。实际上，x最终是-3。
int x;
int array[] = {1, 2, 3};
int *p = &array[1];
x = -1[p]
我在互联网上搜索类似-1指针的东西，但是什么也找不到。好吧，我承认输入正确的搜索查询是很困难的。谁知道为什么-1p会编译，X会变成-3？
浏览 1提问于2019-08-15得票数 21
是这样的吗：
*(1 + &foo)
和这个一样吗？
*(&foo + 1)
'+‘和'&’具有相同的优先级，它们的计算顺序是从右到左。但是，您不能这样解释第二种情况：
*(&(foo + 1))
...because你只能对l值使用'&‘(如果你这样写它，它甚至不会被编译)。那么它会是垃圾吗？或者它会安全地理解你的意思吗？
浏览 8提问于2011-01-27得票数 3
回答已采纳
一般说来，我怎么称呼它呢？我不知道这是一种陈述还是一种一元化的表达，或者别的什么。我猜这是一个一成不变的表达，因为他们只需要一件事:它的论点起作用，对吗？我想我在找一个编译器术语，但我自己找不到。
浏览 5提问于2014-03-10得票数 1
回答已采纳
1回答
Fortran的内置运算符具有定义良好的优先规则。用户定义的操作符呢？我理解用户定义的二进制操作符比每一个内置操作符都具有更低的优先级，正如所明确指出的那样。有可能改变这种行为吗？是否有可能在用户定义的操作符之间建立用户定义的优先级？还是我们只有明智地使用括号来控制操作顺序？
浏览 9提问于2022-05-20得票数 2
回答已采纳
鉴于此：
Object x = null;
考虑一下代码片段#1：
if (x == null || !x.equals(new Object()))
System.out.println("I print!");
代码片段#1不会像我最初认为的那样抛出NullPointerException。我可以在|操作符的帮助下引发异常。代码片段2：
if (x == null | !x.equals(new Object()))
System.out.println("This will throw a NullPointerException..");
浏览 1提问于2013-09-02得票数 1
回答已采纳
在之后，我不知道该怎么想。
在OCaml中，如果您执行类似-1.0**2.0的操作(因为需要使用float类型)，则会得到1.00。根据，结果应该是-1 (与python中一样)。
我找不到原因，也找不到OCaml中运算符优先级的明确定义...
这是因为类型系统吗？还是因为它下面有一个pow绑定？
浏览 2提问于2009-06-02得票数 2
回答已采纳
可以重载二进制运算符以在C++中只使用一个操作数吗？
我尝试用类似于以下类来实现这一点：
#include <iostream>
using namespace std;
class IntWrap {
public:
IntWrap operator=(int rhs) {
val = rhs;
return *this;
}
// No second operand for +
IntWrap operator+() {
IntWrap result;
result = val
浏览 6提问于2015-05-18得票数 1
回答已采纳
2回答
我正在尝试解码的一个程序包括下面这行：
#define nn(sp) ((sp)->nn)
根据上下文(未显示)，我非常确定'sp‘是指向一个结构的指针，该结构包含'nn’作为其变量之一。
在表达式"((sp)->nn)“中，内部的括号集是否有任何可以想象的用途？如果不是，那么最外面的一组括号是否也没有用呢？
浏览 0提问于2013-06-30得票数 0
回答已采纳
我一直致力于在JavaScript中为类实现分流-场算法。
到目前为止，我的工作如下：
var userInput = prompt("Enter in a mathematical expression:");
var postFix = InfixToPostfix(userInput);
var result = EvaluateExpression(postFix);
document.write("Infix: " + userInput + "<br/>");
document.write("Postfix (R
浏览 0提问于2009-10-20得票数 26
我正在处理链接列表，我有以下结构：
typedef struct s_list
{
void *content;
struct s_list *next;
} t_list;
我试图创建一个交换前两个元素的函数，并尝试如下：
void sa(t_list **a)
{
if (!*a && !*a->next)
return ;
}
它给了我以下两个错误：
member reference base type 't_list *' (aka 'struct s_list *&#
浏览 4提问于2022-07-14得票数 1
回答已采纳
1回答
指针从右到左的结合性
、、、
目前，我正在学习C中的指针，但我对右向左结合在增量指针和递增所指向的值方面是如何工作的感到有点困惑。
据了解，++和*在C中都是从右向左结合的。
我不明白*s++是如何提前1移动数组的，但是(*s)++会增加所指向的值，但不会向前移动数组。
例如：
#include <stdio.h>
int main(){
char c[20] = "Help";
char *s;
s = c;
printf("init: %s\n",s); // Help
++*s;
printf("++*s: %s\
浏览 4提问于2020-12-01得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
云直播
对象存储活动推荐
腾讯云开发者
