C语言学习笔记—P14(操作符详解<2>+图解+题例)

简介: C语言学习笔记(操作符详解<2>+图解+题例)

前言:

●由于作者水平有限,文章难免存在谬误之处,敬请读者斧正,俚语成篇,恳望指教!

                                                                     ——By 作者:新晓·故知

image.gif编辑

6. 单目操作符

!           逻辑反操作
-           负值
+           正值
&           取地址
sizeof      操作数的类型长度(以字节为单位)
~           对一个数的二进制按位取反
--          前置、后置--
++          前置、后置++
*           间接访问操作符(解引用操作符)
(类型)       强制类型转换
image.gif

关于sizeof其实我们之前已经见过了,可以求变量(类型)所占空间的大小。

前置++:先++,后使用

#include <stdio.h>
int main()
{
  int a = 10;
  int b = ++a;   前置++,先++,后使用
  printf("a=%d b=%d\n", a, b);
  return 0;
}
image.gif

image.gif编辑

后置++:先使用,再++

#include <stdio.h>
int main()
{
  int a = 10;
  //int b = ++a;   前置++,先++,后使用
  int b = a++;     后置++,先使用,再++
  printf("a=%d b=%d\n", a, b);
  return 0;
}
image.gif

image.gif编辑

int main()
{
  int a = 10;
  //int b = ++a;//前置++,先++,后使用
  //int b = a++;//后置++,先使用,再++
  //printf("a=%d b=%d\n", a, b);
  printf("%d\n", ++a);
  return 0;
}
image.gif

image.gif编辑

int main()
{
  int a = 10;
  //int b = ++a;//前置++,先++,后使用
  //int b = a++;//后置++,先使用,再++
  //printf("a=%d b=%d\n", a, b);
  //printf("%d\n", ++a);
  printf("%d\n", a++);
  return 0;
}
image.gif

image.gif编辑

--  类似:image.gif编辑

image.gif编辑

++和--错误使用编译器会无法正确编译!image.gif编辑

一假则假,后面不再执行

image.gif编辑

X-shell ——Linux教学演示机器:

image.gif编辑

image.gif编辑

image.gif编辑

image.gif编辑

image.gif编辑

强制类型转换:

image.gif编辑

int main()
{
  //int a =  3.14;        3.14 - double -> int a
  int a = (int)3.14;
  printf("%d\n", a);
  return 0;
}
image.gif

image.gif编辑

                                                                                                 ——By 作者:新晓·故知

int main()
{
  //int a = 10;
  int* p = &a;  //这是在创建p变量
  //(int*) p = &a;//err 这样写还没有p变量就进行强制类型转换,错误!
  //int a = (int)3.14;
  //int a = int(3.14);//err
  return 0;
}
image.gif
#include <stdio.h>
int main()
{
 int a = -10;
 int *p = NULL;
 printf("%d\n", !2);
 printf("%d\n", !0);
 a = -a;
 p = &a;
 printf("%d\n", sizeof(a));
 printf("%d\n", sizeof(int));
 printf("%d\n", sizeof a);//这样写行不行?
 printf("%d\n", sizeof int);//这样写行不行?
 return 0;
}
image.gif

image.gif编辑

image.gif编辑image.gif编辑

image.gif编辑image.gif编辑

6.1  sizeof 和数组

void test1(int arr[])
{
  printf("%d\n", sizeof(arr));//(2)
}
void test2(char ch[])
{
  printf("%d\n", sizeof(ch));//(4)
}
int main()
{
  int arr[10] = { 0 };
  char ch[10] = { 0 };
  printf("%d\n", sizeof(arr));//(1)
  printf("%d\n", sizeof(ch));//(3)
  test1(arr);
  test2(ch);
  return 0;
}
image.gif

image.gif编辑

注:

1.test(主函数中的test)传参传的是首元素的地址!

2.test(函数定义的test)中虽然是数组,但本质上是指针!因此test(函数定义的test)中可写为数组也可写为指针 !int arr[ ] ——int *arr。同理char ch[ ]——char *ch。

3.sizeof计算指针的大小不受类型的影响!而指针大小为4个字节(32位机器)或8个字节(64位机器)

X86——32——4

X64——64——8

4.关于(4)输出的为4:因为sizeof计算的是指针的大小,而char是字符的大小(char指向的空间大小)为1个字节,但指针地址(二进制序列32位或64位)为4个字节!

                                                                                                 ——By 作者:新晓·故知

7. 关系操作符

>
>=
<
<=
!=      用于测试“不相等”
==      用于测试“相等”
image.gif

警告: 在编程的过程中== 和=不小心写错,导致的错误!

int main()
{
  int a = 10;
  if (a==5)
  {
    printf("hehe\n");
  }
  else
  printf("a不等于5!\n");
  return 0;
}
image.gif

image.gif编辑

printf的位置影响输出!

image.gif编辑

int main()
{
  int a = 10;
  if (a=5)
  {
    printf("hehe\n");
  }
  else
  printf("a不等于5!\n");
  return 0;
}
image.gif

image.gif编辑

int main()
{
  int a = 10;
  if (5=a)
  {
    printf("hehe\n");
  }
  else
  printf("a不等于5!\n");
  return 0;
}
image.gif

image.gif编辑

int main()
{
  int a = 10;
  if (5==a)      建议的代码习惯
  {
    printf("hehe\n");
  }
  else
  printf("a不等于5!\n");
  return 0;
}
image.gif

image.gif编辑

image.gif编辑image.gif编辑

                                                                                          ——By 作者:新晓·故知

8. 逻辑操作符

逻辑操作符有哪些:
&&          逻辑与
||          逻辑或
image.gif

区分逻辑与和按位与  &

区分逻辑或和按位或   |

1&2----->0
1&&2---->1
1|2----->3
1||2---->1
image.gif

image.gif编辑

int main()
{
  int age = 0;
  scanf("%d", &age);
  if (0 < age < 18)   写法错误,逻辑错误!
  {
    printf("未成年\n");
  }
  return 0;
}
image.gif

image.gif编辑

                                                                                                        ——By 作者:新晓·故知  

int main()
{
  int age = 0;
  scanf("%d", &age);
  //if (0<age < 18)     //错误写法
  if (age>0&&age < 18)  //正确写法
  {
    printf("未成年\n");
  }
  else
  {
    printf("已成年\n");
  }
  return 0;
}
image.gif

image.gif编辑

int main()
{
  int month = 4;//1~12 
  if (month < 1 || month>12)
  {
    printf("范围正确!\n");
  }
  else 
  {
    printf("范围错误!\n");
  }
  return 0;
}
image.gif

image.gif编辑

逻辑与和或的特点:

例:

int main()
{
    int i = 0, a = 0, b = 2, c = 3, d = 4;
    i = a++ && ++b && d++;
    //i = a++||++b||d++;
    printf(" a = %d\n b = %d\n c = %d\n d = %d\n", a, b, c, d);
    return 0;
}
//程序输出的结果是什么?
image.gif

image.gif编辑

int main()
{
    //int i = 0, a = 0, b = 2, c = 3, d = 4;
      int i = 0, a = 1, b = 2, c = 3, d = 4;
    i = a++ && ++b && d++;
    //i = a++||++b||d++;
    printf(" a = %d\n b = %d\n c = %d\n d = %d\n", a, b, c, d);
    return 0;
}
//程序输出的结果是什么?
image.gif

image.gif编辑

image.gif编辑

int main()
{
    int i = 0, a = 0, b = 2, c = 3, d = 4;
    //int i = 0, a = 1, b = 2, c = 3, d = 4;
    //i = a++ && ++b && d++;
    i = a++||++b||d++;  //逻辑或
    printf(" i=%d\n", i);
    printf(" a = %d\n b = %d\n c = %d\n d = %d\n", a, b, c, d);
    return 0;
}
image.gif

image.gif编辑

int main()
{
    //int i = 0, a = 0, b = 2, c = 3, d = 4;
    int i = 0, a = 1, b = 2, c = 3, d = 4;
    //i = a++ && ++b && d++;
    i = a++||++b||d++;  //逻辑或
    printf(" i=%d\n", i);
    printf(" a = %d\n b = %d\n c = %d\n d = %d\n", a, b, c, d);
    return 0;
}
image.gif

image.gif编辑

image.gif编辑

9. 条件操作符

exp1 ? exp2 : exp3
image.gif

练习:

1.
if (a > 5)
        b = 3;
else
        b = -3;
转换成条件表达式,是什么样?
b=(a>5? 3:-3);
image.gif

 10. 逗号表达式

exp1, exp2, exp3, …expN
image.gif

逗号表达式,就是用逗号隔开的多个表达式。 逗号表达式,从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

int main()
{
  int a = 10;
  int b = 20;
  int max = 0;
  if (a > b)
    max = a;
  else
    max = b;
  //条件操作符
  //max = (a > b ? a : b);
  printf("%d\n", max);
  re
image.gif

image.gif编辑

image.gif编辑

//代码3
a = get_val();
count_val(a);
while (a > 0)
{
  //业务处理
        a = get_val();
        count_val(a);
}
如果使用逗号表达式,改写:
while (a = get_val(), count_val(a), a>0)
{
         //业务处理
}
image.gif

11. 下标引用、函数调用和结构成员

11.1. [ ] 下标引用操作符 操作数:一个数组名 + 一个索引值

int arr[10];   创建数组
 arr[9] = 10;  实用下标引用操作符。
 [ ]的两个操作数是arr和9。
image.gif

image.gif编辑1.[ ] 就是下标引用操作符,arr,7是操作数

2.arr[7]--> *(arr+7) --> *(7+arr)-->7[arr]

 

int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  printf("%d\n", arr[7]);            1.[] 就是下标引用操作符,arr,7是操作数
                                     2.arr[7]--> *(arr+7) --> *(7+arr)-->7[arr]
  printf("%d\n", arr[7]);
  printf("%d\n", 7[arr]);
  return 0;
}
image.gif

image.gif编辑

                                                                                                         ——By 作者:新晓·故知

11.2. ( ) 函数调用操作符 接受一个或者多个操作数:第一个操作数是函数名,剩余的操作数就是传递给函数的参数。

void test()
{
  printf("hehe\n");
}
int Add(int x, int y)
{
  return x + y;
  printf("%d\n",x+y);
}
int main()
{
  test();                    () - 函数调用操作符
  int ret = Add(2, 3);  
  printf("%d\n", ret);
  return 0;
}
image.gif

image.gif编辑

() - 函数调用操作符

void test()
{
  printf("hehe\n");
}
int main()
{
  test();       //() - 函数调用操作符
  return 0;
}
image.gif

image.gif编辑

#include <stdio.h>
 void test1()
 {
 printf("hehe\n");
 }
 void test2(const char *str)
 {
 printf("%s\n", str);
 }
 int main()
 {
 test1();              实用()作为函数调用操作符。
 test2("hello bit.");  实用()作为函数调用操作符。
 return 0;
 }
image.gif

11.3. 访问一个结构的成员

.   结构体.成员名
->  结构体指针->成员名
image.gif

                                                                                          ——By 作者:新晓·故知                

struct Stu
{
  char name[20];
  int age;
  double score;
};
int main()
{
  struct Stu s = {"zhangsan", 20, 85.5};
  //.
  printf("%s %d %.1lf\n", s.name, s.age, s.score);          结构体变量.结构体成员
  //->
  struct Stu * ps = &s;
  printf("%s %d %.1lf\n", (*ps).name, (*ps).age, (*ps).score);
  printf("%s %d %.1lf\n", ps->name, ps->age, ps->score);    结构体指针->结构体成员
  return 0;
}
image.gif

image.gif编辑

image.gif编辑

image.gif编辑

#include <stdio.h>
struct Stu
{
 char name[10];
 int age;
 char sex[5];
 double score;
};
void set_age1(struct Stu stu)
{
 stu.age = 18;
}
void set_age2(struct Stu* pStu)
{
 pStu->age = 18;//结构成员访问
}
int main()
{
 struct Stu stu;
 struct Stu* pStu = &stu;   结构成员访问
 stu.age = 20;              结构成员访问
 set_age1(stu);
 pStu->age = 20;            结构成员访问
 set_age2(pStu);
 return 0;
}
image.gif

12. 表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。 同样,有些表达式的操作数在求值的过程中可能需要转换为其他类型。

12.1 隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度,表达式中的字符和短整型操作数在使用之前被转换为普通整型,

这种转换称为整型提升

int main()
{
  char a = 5;
  char b = 126;
  char c = a + b;
  printf("%d\n", c);
  return 0;
}
image.gif

image.gif编辑

sizeof(char)和sizeof(short)均小于sizeof(int)

image.gif编辑image.gif编辑

                                                                                                         ——By 作者:新晓·故知

int main()
{
  char a = 5;
  //截断
  //00000000000000000000000000000101
  //00000101    char类型一个字节,8个bit位
  char b = 126;
  //00000000000000000000000001111110
  //01111110
  //整型提升
  //00000000000000000000000000000101 - a
  //00000000000000000000000001111110 - b
  //提升后相加
  //00000000000000000000000010000011
  //10000011 - c
  //当a和b相加的时候,a和b都是char类型
  //表达式计算的是就要发生整形提升
  //
  char c = a + b;
  //10000011 - c  符号位为1则提升时添加的是1
  //11111111111111111111111110000011 - 补码
  //11111111111111111111111110000010
  //10000000000000000000000001111101 -> -125
  printf("%d\n", c);//?
  return 0;
}
image.gif

char:截断存储->整形提升->运算—>截断存储

存储的是补码,printf打印的是原码image.gif编辑

整型提升的意义:

表达式的整型运算要在CPU的相应运算器件内执行,CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度,同时也是CPU的通用寄存器的长度。

因此,即使两个char类型的相加,在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。

通用CPU(general-purpose CPU)是难以直接实现两个8比特字节直接相加运算(虽然机器指令中可能有这种字节相加指令)。所以,表达式中各种长度可能小于int长度的整型值,都必须先转换为int或unsigned int,然后才能送入CPU去执行运算。

实例1

实例1
char a,b,c;
...
a = b + c;
image.gif

b和c的值被提升为普通整型,然后再执行加法运算,

加法运算完成之后,结果将被截断,然后再存储于a中。

如何进行整体提升呢?

整形提升是按照变量的数据类型的符号位来提升的

1.负数的整形提升

char c1 = -1;

变量c1的二进制位(补码)中只有8个比特位:

1111111

因为 char 为有符号的 char

所以整形提升的时候,高位补充符号位,即为1

提升之后的结果是:

11111111111111111111111111111111

2.正数的整形提升

char c2 = 1;

变量c2的二进制位(补码)中只有8个比特位:

00000001

因为 char 为有符号的 char

所以整形提升的时候,高位补充符号位,即为0

提升之后的结果是:

00000000000000000000000000000001

无符号整形提升,高位补0

 

整形提升的例子:

实例1
int main()
{
 char a = 0xb6;
 short b = 0xb600;
 int c = 0xb6000000;
 if(a==0xb6)
 printf("a");
 if(b==0xb600)
 printf("b");
 if(c==0xb6000000)
 printf("c");
 return 0;
}
image.gif

image.gif编辑image.gif编辑

 实例1中的a,b要进行整形提升,但是c不需要整形提升

a,b整形提升之后,变成了负数,

所以表达式 a==0xb6 , b==0xb600 的结果是假,

但是c不发生整形提升,

则表 达式 c==0xb6000000 的结果是真.

所程序输出的结果是: c

实例2
int main()
{
 char c = 1;
 printf("%u\n", sizeof(c));
 printf("%u\n", sizeof(+c));
 printf("%u\n", sizeof(-c));
 return 0;
}
image.gif

image.gif编辑

实例2中的,c只要参与表达式运算,

就会发生整形提升,表达式 +c ,就会发生提升,

所以 sizeof(+c) 是4个字

节.

表达式 -c 也会发生整形提升,

所以 sizeof(-c) 是4个字节,

但是 sizeof(c) ,就是1个字节

image.gif编辑

                                                                                           ——By 作者:新晓·故知

12.2 算术转换

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

long double
double
float
unsigned long int
long int
unsigned int
int
image.gif
int main()
{
  int a = 3;
  float f = 5.5;
  float r = a + f;//算术转换
  printf("%.1f\n",r);
  return 0;
}
image.gif

image.gif编辑

int main()
{
  int a = 10;
  int b = 20;
  a + b;        表达式有2个属性:值属性,类型属性
                30 就是值属性
                int 类型属性
  return 0;
}
image.gif

image.gif编辑

int main()
{
  short s = 20;
  int a = 5;
  printf("%d\n", sizeof(s = a + 4));//?
  printf("%d\n", s);//?
  return 0;
}
image.gif

image.gif编辑image.gif编辑

image.gif编辑

如果某个操作数的类型在上面这个列表中排名较低,那么首先要转换为另外一个操作数的类型后执行运 算。 警告: 但是算术转换要合理,要不然会有一些潜在的问题。

float f = 3.14;
int num = f;        隐式转换,会有精度丢失
image.gif

                                                                                                        ——By 作者:新晓·故知

12.3 操作符的属性

复杂表达式的求值有三个影响的因素。

1. 操作符的优先级

2. 操作符的结合性

3. 是否控制求值顺序。

两个相邻的操作符先执行哪个?取决于他们的优先级。如果两者的优先级相同,取决于他们的结合性。 操作符优先级

image.gif编辑

一些问题表达式

//表达式的求值部分由操作符的优先级决定。
//表达式1
a*b + c*d + e*f
image.gif

image.gif编辑

同一个表达式的计算路径已经产生了不同!这种代码有问题!若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
image.gif
//表达式2
c + --c;
image.gif

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

代码3-非法表达式
int main()
{
 int i = 10;
 i = i-- - --i * ( i = -3 ) * i++ + ++i;
 printf("i = %d\n", i);
 return 0;
}
image.gif

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

代码4
int fun()
{
     static int count = 1;
     return ++count;
}
int main()
{
     int answer;
     answer = fun() - fun() * fun();
     printf( "%d\n", answer);//输出多少?
     return 0;
}
image.gif

static 函数出函数体不销毁,产生累积

image.gif编辑

这个代码有没有实际的问题?

有问题! 虽然在大多数的编译器上求得结果都是相同的。 但是上述代码 answer = fun() - fun() * fun(); 中我们只能通过操作符的优先级得知:先算乘法, 再算减法。 函数的调用先后顺序无法通过操作符的优先级确定。

代码5
#include <stdio.h>
int main()
{
 int i = 1;
 int ret = (++i) + (++i) + (++i);
 printf("%d\n", ret);
 printf("%d\n", i);
 return 0;
}
image.gif

尝试在linux 环境gcc编译器、VS2019环境下都执行,看结果。

image.gif编辑

VS2019环境的结果:image.gif编辑

image.gif编辑image.gif编辑

不同编译器计算顺序不同!image.gif编辑

看看同样的代码产生了不同的结果,这是为什么?

简单看一下汇编代码.就可以分析清楚. 这段代码中的第一个 + 在执行的时候,第三个++是否执行,这个是不确定的,因为依靠操作符的优先级 和结合性是无法决定第一个 + 和第 三个前置 ++ 的先后顺序。

总结:

我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径,那这个表达式就是存在问题 的。

                                                                                          ——Since 新晓-故知

相关文章
|
3天前
|
存储 C语言 索引
【C语言基础】:操作符详解(二)
【C语言基础】:操作符详解(二)
|
3天前
|
存储 编译器 C语言
【C语言基础】:操作符详解(一)
【C语言基础】:操作符详解(一)
TU^
|
3天前
|
存储 C语言
C语言之操作符
C语言之操作符
TU^
8 0
|
4天前
|
IDE 开发工具 C语言
C primer plus 学习笔记 第2章 C语言概述
C primer plus 学习笔记 第2章 C语言概述
|
4天前
|
存储 Unix 编译器
C primer plus 学习笔记 第1章 初识C语言
C primer plus 学习笔记 第1章 初识C语言
|
11天前
|
C语言
C语言学习记录——操作符习题、算数转换习题,多解法&优解法&单选题
C语言学习记录——操作符习题、算数转换习题,多解法&优解法&单选题
11 1
|
11天前
|
编译器 C语言
C语言学习记录——操作符详解知识点选记(算术操作符、单目操作符、移位操作符、关系操作符、逻辑操作符、条件操作符......)二
C语言学习记录——操作符详解知识点选记(算术操作符、单目操作符、移位操作符、关系操作符、逻辑操作符、条件操作符......)二
20 3
|
11天前
|
存储 编译器 C语言
C语言学习记录——操作符详解知识点选记(算术操作符、单目操作符、移位操作符、关系操作符、逻辑操作符、条件操作符......)一
C语言学习记录——操作符详解知识点选记(算术操作符、单目操作符、移位操作符、关系操作符、逻辑操作符、条件操作符......)一
17 1
|
12天前
|
存储 C语言
C语言:详解操作符(下)
C语言:详解操作符(下)
13 3
|
12天前
|
存储 编译器 C语言
C语言:详解操作符(上)
C语言:详解操作符(上)