C语言—操作符、常见关键字、指针 3

1、'\0'  0   '0'  的区别

'\0'：是字符串'abcd\0'的结束标志，是转义字符，数值为0

0：只与'\0'的数值相同

'0'：属于字符，ACSII的值为48，不过相对而言是数字字符，其他：'a'  'c'  'q' 是字母字符

EOF——end of file—文件结束标志，值为-1

eg：使用自定义函数Min，求最小值

#include <stdio.h>
#include <string.h>

int Min(int x,int y)
{
	if(x>y)
		return y;
	else
		return x;
}
int main()
{
	int num1=10;
	int num2=20;
	int min=0;
	min=Min(num1,num2);
	printf("min=%d\n",min);
	return 0;
}

sizeof介绍：

int a=10;
int arr[]={1,2,3,4,5,6}; //数组大小=4*6，
//最前面的int指的是数组中元素的数据类型 相当于int[6]
printf("%d\n",sizeof(a)); //结果4
printf("%d\n",sizeof a);//结果4
//前两行结果相等，括号是可以省略的，是由于sizeof是操作符 不受影响；
如果是函数a两边括号不能省略的
//(a)也可以写为(int),但是int两边的括号不能省略 语法-类型错误
printf("%d\n",sizeof(arr)/sizeof(arr[0]));\\求所在数组含有的元素个数

——————————————————————

一、操作符

总结：

单目操作符：

-：负值

+：正值

&：取地址

*：间接访问操作符（解引用操作符）

sizeof：操作数的类型长度（以字节为单位）

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

--：前置、后置--      ||      ++：前置、后置++

（类型）：强制类型转换

——————————————————————

介绍：

1、~：按（二进制）位取反

eg：00110101

~：  11001010

//原码、反码、补码（原码 按位取反得 反码，反码加一得补码）

正数——原码、反码、补码 都相同

最高位是符号位

负数在内存中存储的时候，存储的是二进制的补码；

所以需要把补码 转换为 反码，再转换为 原码

#include <stdio.h>

int main()
{
	int a=0;//4个字节bub，最高位是符号位(最高位为1为负，为0为正）
//00000000 00000000 00000000 00000000
//11111111 11111111 11111111 11111111
	

//原码、反码、补码（原码按位取反得 反码，反码加一得补码）
//负数在内存中存储的时候，存储的是二进制的补码
？？（负数对应补码？）
把补码 转换为 反码，再转换为 原码
补码：//11111111 11111111 11111111 11111111
反码：//11111111 11111111 11111111 11111110
原码：//10000000 00000000 00000000 00000001——得到-1
printf("%d\n",b);//打印的是数的原码

//11111111111111111111111111111111  加一得到下面一行结果
//10000000000000000000000000000000  减一得上面一行结果

整型是32位，规定最左边的32位是体现正负的，0为正 1为负

2、++/--：前置、后置++/--（--与++同理）

前置++(eg：++a），先++  再使用/赋值

后置++(eg：a++），先使用/赋值  再++

#include <stdio.h>
#include <string.h>

int main()
{
	int a=10;
	int b=a++;//后置++ 得到a：11，b：10
   int b=++a;//前置++ 得到a：11，b：11
	printf("a=%d b=%d\n",a,b);

   return 0;
}

3、（类型）：强制类型转换

类型指的是数据类型（eg：char、short、int、long、long long、float、double）

eg：

#include <stdio.h>
#include <string.h>

int main()
{
	int a=（int）3.14;//（int）指把小数3.14强制转化为整型 double——>int

   return 0;
}

关系操作符

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

逻辑操作符

&&   逻辑与 （全真才为真）

||    逻辑或   （一真就为真，全假才为假）

#include <stdio.h>
#include <string.h>

int main()
{
	int a=3;
	int b=5;
	int c=a && b;

	printf("%d\n",c); //输出为1

   return 0;
}

————————————

0为正，1为负

0为假，非0为真

————————————

条件操作符-某种程度可以替换if语句

exp1 ? exp2 : exp3   （eg:a>b？a：b）

#include <stdio.h>
#include <string.h>

int main()
{
	int a=10;
	int b=8;
	int max=(a>b?a:b);//判断a是否大于b，后输出两数的最大值，可以替换if语句

	printf("%d\n",max);

   return 0;
}

逗号表达式

exp1,exp2,exp3,...expN

下标引用[]、函数调用()和结构成员

[]    ()     .    ->

#include <stdio.h>
#include <string.h>

int main()
{
	int arr[10]={0};
	arr[4];//[]:下标引用操作符

   return 0;
}

int Add(int x,int y)
{
	int z=0;
	z=x+y;
	return 0;
}
int main()
{
	int a=1;
	int bF=4;
  int sum=0；
	sum=Add(a,b);//():函数调用操作符

二、常见关键字

变量不能与关键字冲突

auto  break（停止循环）  case  char  const（常量，常变量）  continue（继续，使用于循环语句）  default（默认）  do（do..while循环）  double  else（if...else）  enum（枚举）extern（引入外部符号）  float  for  goto（语句）  if  int  long  register（寄存器）  return  short  signed  sizeof  static（静态）  struct（结构体关键字）  switch（语句）  typedef（类型定义-类型重定义）  union（联合体/共用体）  unsigned  void  volatile while

//auto-自动
auto int a=10;//局部变量-a是自动创建也是自动销毁的，
所以也称为：自动变量（局部变量前都有auto，所以就都省略了）

局部变量都是自动变量

计算机存储数据：

寄存器（相对访问速度最快）register

高速缓存

内存

硬盘

int main()
{
	register int a=10;//建议把a定义为寄存器变量
  return 0；
}

signed：有符号的

int a=10;
a=-2;
//int 定义的变量是有符号的，为signed int;unsigned是无符号的，所有数都会被
认为是正数
unsigned int num=-1;

typedef：类型重定义

int main（）
{
	typedef unsigned int u_int;//给unsigned int起了一个别名为u_int
  unsiged int num=20;
  u_int num2=20;
  
  return 0;
}

static：

修饰局部变量，使局部变量的生命周期延长

修饰全局变量，改变了变量的作用于，让静态的全局变量只能在自己所在的源文件内部使用，出了源文件就无法使用

修饰函数，改变了函数的链接属性；

函数一般是有外部链接属性的，使用了static后就变成了内部链接属性

1、修饰局部变量

#include <stdio.h>
#include <string.h>

void test()
{
	static int a=1;//当没有static时输出为五个2，由于a是局部变量，
a++是就会给a加一
//当加上static输出为2、3、4、5、6
	a++;
	printf("a=%d\n",a);	
}
int main() //运行函数都是先从main函数开始
{
	int i=0;
	while(i<5)
	{
		test();
		i++;
	}
	return 0;
}

快捷键：Fn+F10调试      +调试——监视窗口

2、修饰全局变量

写两个源文件，一个用于供另一调用

#include <stdio.h>

int main()
{
	//extern:声明外部符号
  extern int g_val;
  printf("g_val=%d\n",g_val);
  return 0;
}

static int g_val=2020;//当在前面加入static就无法调用g_val

3、修饰函数

创建两个源文件，一个定义函数，一个引用

static int Add(int x,int y)  //在前面加入了static，
也会使另一个源文件无法调用该函数
{
	int z=x+y;
  return z;
}

//声明外部函数
extern int Add(int,int);

int main()
{
	int a=10;
  int b=20;
  int sum=Add(a,b);
  printf("sum=%d\n",sum);
  return 0;
}

#define ：定义标识符常量，定义宏——带参数

#include <stdio.h>
#define MAX 100

int main()
{
	int a=MAX;//输出a为100
  return 0;
}

#define MAX(X,Y) (X>Y?X:Y)   //求最大值

#include <stdio.h>


int Max(int x,int y)
{
	if(x>y)
		return x;
	else
		return y;
}	

//宏的定义
#define MAX(X,Y) (X>Y?X:Y)

int main()
{
	int a=20;
	int b=10;
  //函数的实现
	int max=Max(a,b);
	printf("max=%d\n",max);
	
  //宏的方式
	max=MAX(a,b);//相当于 max=(a>b?a:b)
	printf("max=%d\n",max);
	
	return 0;
}

三、指针

每个内存单元的大小是1个字节

为了有效的访问到内存的每个单元，给内存单元进行了编号，这些编号称为该内存单元的地址

地址对应空间，编号从0开始，编号对应地址

如何产生地址？

答：32位电脑——对应有32根地址线/数据线，电分为正电1  负电0

以字节为单位划分

#include <stdio.h>


int main()
{
	int a=10; //分配4个字节
  int* p=&a;//取地址
  //有一种变量是用来存放地址的变量——称为 指针变量
	printf("%p\n",&a);
  printf("%p\n",p);
	
	*p=20;//*：解引用操作符，把之前定义的a的地址中的数据 更改为20
	printf("a=%d\n",a);//输出a=20
	
	return 0;
}

#include <stdio.h>


int main()
{
	char ch='w';
	char* pc=&ch;
	*pc='a';
	printf("%c\n",ch);//输出为
  
	return 0;
}

结论：指针大小在32位平台是（32比特/8=4）4个字节，64位平台是8个字节

#include <stdio.h>


int main()
{
	char ch='w';
	char* pc=&ch;
	
	printf("%ld\n",sizeof(pc));//计算指针大小
	return 0;
	
}