掌握操作符（二）：结构成员访问操作符，操作符的属性：优先级、结合性，表达式求值

最新推荐文章于 2025-05-17 18:10:58 发布

艾莉丝努力练剑

最新推荐文章于 2025-05-17 18:10:58 发布

阅读量1.1k

点赞数 28

分类专栏： C语言文章标签： c语言开发语言学习

本文链接：https://blog.csdn.net/2401_89899187/article/details/147960935

版权

C语言专栏收录该内容

19 篇文章

订阅专栏

🔥个人主页：艾莉丝努力练剑

🍓专栏传送门：《C语言》

🍉学习方向：C/C++方向

⭐️人生格言：为天地立心，为生民立命，为往圣继绝学，为万世开太平

前言:前面几篇文章介绍了c语言的一些知识，包括循环、数组、函数、VS实用调试技巧、函数递归等，在这篇文章中，我将继续介绍操作符的一些重要知识点！由于操作符的内容较多，博主将会撰写两篇来详解操作符，这是下篇，对操作符感兴趣的友友们可以在评论区一起交流学习！

九、结构成员访问操作符

（一）结构体

1、结构的声明

struct tag

{
 member-list;
}variable-list;

我们这里举个例子：比如说，描述一个学生：

struct Stu

{
 char name[20];//名字 
 int age;//年龄 
 char sex[5];//性别 
 char id[20];//学号 
}; //分号不能丢

注意：当然在注释中我也标注了“分号不能丢” ，切记这里的分号要保留，不要掉了。

2、结构体变量的定义和初始化

代码1：变量的定义

struct Point

{
 int x;
 int y;
}p1; //声明类型的同时定义变量p1 

struct Point p2; //定义结构体变量p2

代码2：初始化

struct Point p3 = {10, 20};

struct Stu //类型声明

{
 char name[15];//名字 
 int age; //年龄 
};

struct Stu s1 = {"zhangsan", 20};//初始化 

struct Stu s2 = {.age=20, .name="lisi"};//指定顺序初始化

代码3：

struct Node

{
 int data;
 struct Point p;
 struct Node* next; 
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化 

struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

（二）结构成员访问操作符

1、结构体成员的直接访问

结构体成员的直接访问是通过点操作符（.）访问的。点操作符接受两个操作数。如下：

#include <stdio.h>

struct Point

{
 int x;
 int y;
}p = {1,2};

int main()
{
 printf("x: %d y: %d\n", p.x, p.y);
 return 0;
}

使用方式：结构体变量 . 成员名

2、结构体成员的间接访问

有时候我们得到的不是一个结构体变量，而是得到了一个指向结构体的指针。如下：

#include <stdio.h>

struct Point

{
 int x;
 int y;
};
int main()
{
 struct Point p = {3, 4};
 struct Point *ptr = &p;
 ptr->x = 10;
 ptr->y = 20;
 printf("x = %d y = %d\n", ptr->x, ptr->y);
 return 0;
}

使用方式：结构体指针 - > 成员名

关于结构体成员的间接访问，我会在指针部分继续介绍，这里我们先了解一下！

（三）综合举例

咱们综合上面介绍的知识，实现一个代码：

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

#include <string.h>

struct Stu

{
	char name[15];//名字 
	int age; //年龄 
};

void print_stu(struct Stu s)
{
	printf("%s %d\n", s.name, s.age);
}

void set_stu(struct Stu* ps)
{
	strcpy(ps->name, "李四");
	ps->age = 28;
}

int main()
{
	struct Stu s = { "张三", 20 };
	print_stu(s);
	set_stu(&s);
	print_stu(s);
	return 0;
}

更多关于结构体的知识，博主会在之后介绍自定义类型——结构体——部分时详细讲解。

十、操作符的属性：优先级、结合性

C语言的操作符有2个重要的属性：优先级、结合性，这两个属性决定了表达式求值的计算顺序。

（一）优先级

重要提醒：优先级指的是，如果一个表达式包含多个运算符，哪个运算符应该优先执行。各种运算符的优先级是不一样的。

咱们举个例子：

1 + 2 * 3;

上面示例中，表达式 1 + 2 * 3 里面既有加法运算符（ + ），又有乘法运算符（ * ）。由于乘法
的优先级高于加法，所以会先计算 2 * 3 ，而不是先计算 1 + 2 。

（二）结合性

两个运算符如果优先级相同，光凭优先级就已经没办法确定先计算哪个了，这时候就得看结合性了，根据运算符是左结合，还是右结合，决定执行顺序。大部分运算符是左结合（从左到右执行），少数运算符是右结合（从右到左执行），比如赋值运算符（ = ）。

再举个例子：

3 * 4 / 2;

上面示例中， * 和 / 的优先级相同，它们都是左结合运算符，所以从左到右执行，先计算 3 * 4 ，
再计算 / 2 。

运算符的优先级顺序很多，下面是部分运算符的优先级顺序（按照优先级从高到低排列），博主建议友友们大致记住这些操作符的优先级就可以了，其他操作符在使用的时候查看下面表格就行：

1.圆括号（ () ）

2.自增运算符（ ++ ），自减运算符（ - - ）

3.单目运算符（ + 和 - ）

4.乘法（ * ），除法（ / ）

5.加法（ + ），减法（ - ）

6.关系运算符（ < 、 > 等）

7.赋值运算符（ = ）

由于圆括号的优先级最高，可以使用它改变其他运算符的优先级。

这里给大家推荐一个网址：C 运算符优先级

这个网站我在之前的博客已经给大家推荐了这个网站，有需要的友友们可以坐传送门去看看：掌握函数（一）：库函数与自定义函数、形参与实参、return语句

十一、表达式求值

（一）整型提升

C语言中整型算术运算总是至少以缺省（默认）整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

为什么要整型提升？这里我们介绍一下整型提升的意义。

意义：表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长
度。
通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。

咱们这里举个实际的例子：

char a,b,c;
...
a = b + c;

b和c的值被提升为普通整型，然后再执行加法运算。
加法运算完成之后，结果将被截断，然后再存储于a中。

如何进行整体提升呢？

两步走战略：

1.有符号整数提升是按照变量的数据类型的符号位来提升的；

2. 无符号整数提升，高位补0。

//负数的整形提升 
char c1 = -1;
变量c1的⼆进制位(补码)中只有8个⽐特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，⾼位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111

//正数的整形提升 
char c2 = 1;
变量c2的⼆进制位(补码)中只有8个⽐特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，⾼位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001

//⽆符号整形提升，⾼位补0

（二）算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。

long double
double
float
unsigned long int
long int
unsigned int
int

如果某个操作数的类型在上面这个列表中排名靠后，那么首先要转换为另外一个操作数的类型后执行运算。

（三）问题表达式解析

这里我们通过五个表达式来解析问题表达式：

表达式1：

//表达式的求值部分由操作符的优先级决定。 

//表达式1 
a*b + c*d + e*f

表达式1在计算的时候，由于 * 比 + 的优先级高，只能保证， * 的计算是比 + 早，但是优先级并不
能决定第三个 * 比第一个 + 早执行。

表达式的计算机顺序：

a*b
c*d
a*b + c*d
e*f
a*b + c*d + e*f

或者这样：

a*b
c*d
e*f
a*b + c*d
a*b + c*d + e*f

表达式2：

//表达式2 
c + --c;

同上，操作符的优先级只能决定自减 - - 的运算在 + 的运算的前面，但是我们并没有办法得知， + 操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义的。

表达式3：

//表达式3 

int main()
{
 int i = 10;
 i = i-- - --i * ( i = -3 ) * i++ + ++i;
 printf("i = %d\n", i);
 return 0;
}

表达式3在不同编译器中测试结果：非法表达式程序的结果

表达式4：

#include <stdio.h>

int fun()
{
 static int count = 1;
 return ++count;
}

int main()
{
 int answer;
 answer = fun() - fun() * fun();
 printf( "%d\n", answer);//输出多少？ 
 return 0;
}

这个代码有没有实际的问题？有问题！
虽然在大多数的编译器上求得结果都是相同的。但是上述代码 answer = fun() - fun() * fun(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。

函数的调用先后顺序无法通过操作符的优先级确定。

表达式5：

//表达式5 

#include <stdio.h>

int main()
{
 int i = 1;
 int ret = (++i) + (++i) + (++i);
 printf("%d\n", ret);
 printf("%d\n", i);
 return 0;
}

//尝试在linux 环境gcc编译器，VS2013环境下都执⾏，看结果。

这是gcc编译器执行的结果：