C learning_3(下)

简介: C learning_3

C learning_3(上):https://developer.aliyun.com/article/1424322


8.数组的下标


       有了上述的数组,我们该怎么拿到每个同学的成绩呢?C语言规定:数组的每个元素都有一个下标,下标是从0开始的。 数组可以通过下标来访问的。


       比如:

#include<stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  //    下标:    0 1 2 3 4 5 6 7 8 9
  //要拿到元素5 - 用下标4访问
  printf("%d", arr[4]);
  //拿到所有元素 - 遍历下标即可
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}


9.操作符


算术操作符


+         -         *         /         %

#include<stdio.h>
int main()
{
  int x = 10;
  int y = 6;
  printf("%d\n", x + y);//16
  printf("%d\n", x - y);//4
  //乘号不能写成 - x
  printf("%d\n", x * y);//60
  /*  
  除法 - /
    1.计算结果是整除之后得到的商
    2.除法有:
    整数除法
    浮点数除法 - 保证除数和被除数至少有一个是浮点数
  取模/取余 %
    得到的是余数 - 操作符两边的数都必须是整型
  */
  printf("%d\n", x / y);//1
  printf("%lf\n",10 / 6.0);//1.666667
  printf("%lf\n", 10.0 / 6.0);//1.666667
  printf("%lf\n", 10.0 / 6);//1.666667
  printf("%d\n", x % y);//4
  return 0;
}


移位操作符


>>         <<


位操作符


&         ^         |


赋值操作符


=         +=         -=         *=         /=         &=         ^=          |=            >>=           <<=

#include<stdio.h>
int main()
{
  int a = 0;
  a = 5;//赋值
  a = a + 5;//等价 a += 5; - 复合赋值
  return 0;
}


单目操作符


!                                          逻辑反操作

-                                          负值

+                                         正值

&                                         取地址

sizeof                                  操作数的类型长度(以字节为单位)

~                                         对一个数的二进制按位取反

--                                         前置、后置--

++                                       前置、后置++

*                                          间接访问操作符

(解引用操作符) (类型)         强制类型转换

#include<stdio.h>
int main()
{
  //双目操作符 - 只有一个操作数
  //单目操作符 - 只有一个操作数
  //在C语言中,非0 - 表示真,0 - 表示假
  int a = 5;
  if (a)//a为真进入if
    printf("X\n");
  if (!a)//a为假进入if
    printf("x\n");
  printf("%d\n", !a);//0
  int a = 5;
  int b = 0;
  b = -a;
  printf("%d\n", b);
  int a = 0;
  //sizeof 操作符,不是函数
  //sizeof计算的是变量所占有内存的大小、单位是字节
  printf("%d\n", sizeof(a));//4
  printf("%d\n", sizeof a);//4
  printf("%d\n", sizeof(int));//4
  printf("%d\n", sizeof int);//error
  int a = 1;
  int d = ++a;//前置++ - 先加加后使用
  /*
    a = a+1;
    d = a;
    a = 2 , d = 2
  */
  int e = a++;//后置++ - 先使用后加加
  /*
    e = a;
    a = a+1;
    a = 2 , e = 1
  */
  return 0;
}


接下来,我们看一段关于前置++和后置++配合使用的代码,看看输出的结果是什么?

#include<stdio.h>
int main()
{
  int a = 1;
  int b = (++a) + (++a) + (++a);
  printf("%d", b);
}


vs2022测试的结果:


IDEA2020测试的结果


关系操作符

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
  int a = 4;
  int b = 5;
  if (a == b)//测试相等
  {
    printf("1\n");
  }
  else//a != b - 测试不相等
  {
    printf("2\n");
  }
  return 0;
}


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


逻辑操作符

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
  //并且 && 逻辑与 两个操作数都为真才为真,只要有一个为假就为假
  //或者 || 逻辑或 两个操作数都为假才为假,只要有一个为真就为真
  int a = 0;
  int b = 5;
  if (a && b)//假
  {
    printf("1\n");
  }
  if (a || b)//真
  {
    printf("2\n");
  }
  return 0;
}


&&     逻辑与         ||          逻辑或


条件操作符

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
  //exp1 ? exp2 : exp3 - 三目操作符
  /*
    exp1为真,执行exp2,不执行exp3
    exp1为假,执行exp3,不执行exp2
  */
  int a = 0;
  int b = 0;
  //输入
  scanf("%d %d", &a, &b);
  //找到a和b之间的最大值
  /*
  int m = 0;
  if (a > b)
    m = a;
  else
    m = b;
  */
  /*不推荐
  int m = 0;
  (a > b) ? (m = a) : (m = b);
  */
  /*三目操作符的使用
  int m = 0;
  m = a > b ? a : b;
  */
  return 0;
}


exp1 ? exp2 : exp3


逗号表达式

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
  //逗号表达式
  //exp1, exp2, exp3......
  //从左向右依次计算,结果是最后一个表达式的结果
  int a = 3;
  int b = 2;
  int c = 5;
  int d = (a += 3, b = 5, c = a + b, c - 4);
  //       a=6     b=5    c=11       c=7
  return 0;
}


exp1, exp2, exp3, …expN


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

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  //              0 1 2 3 4 5 6 7 8 9
  //数组下标从0开始
  //[]是一个下标引用操作符
  printf("%d\n", arr[5]);//6
  return 0;
}
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int Add(int x, int y)
{
  return x + y;
}
int main()
{
  int z = Add(3, 5);//函数调用操作符
  printf("Hello");//函数调用操作符
  return 0;
}


[]         ()         .         ->


9.操作符的优先级


       当操作配合使用时,我们要牢记以下口诀,才能在以后的使用出现不必要的错误


口诀:

单目运算排第一;

乘除余二加减三;

移位四,关系五;

等和不等排第六;

位与、异或和位或;

短路与和短路或;

依次从七到十一;

条件排在第十二;

赋值一定是最后;

相关文章
|
6月前
|
机器学习/深度学习 传感器 自然语言处理
Deep Learning
【6月更文挑战第7天】
45 2
|
6月前
|
机器学习/深度学习 数据采集 人工智能
Supervised Learning
【6月更文挑战第7天】
54 2
|
7月前
|
存储 编译器 C语言
C learning_2
C learning_2
|
7月前
|
编译器 C语言
C learning_1
C learning_1
|
7月前
|
算法 C语言 数据安全/隐私保护
C learning_6
C learning_6
|
7月前
|
存储 API 数据安全/隐私保护
C learning_7
C learning_7
|
7月前
|
存储 安全 程序员
C learning_5
C learning_5
|
7月前
|
存储 缓存 安全
C learning_4
C learning_4
|
7月前
|
存储 C语言 C++
|
7月前
|
存储 算法 Unix
C learning_8
C learning_8